/**
 * SD-LoRA校园图片生成系统 - API通信模块
 */

const api = {
    /**
     * 发送用户消息
     * @param {string} message - 用户消息
     * @param {string|null} sessionId - 会话ID
     * @param {string} mode - 模式（chat或draw）
     * @param {string} model - 模型名称
     * @param {Object|null} advancedSettings - 高级设置参数
     * @returns {Promise} - 返回Promise对象
     */
    sendMessage: (message, sessionId = null, mode = 'chat', model = 'deepseek-chat', advancedSettings = null) => {
        const requestData = {
            message,
            session_id: sessionId,
            mode,
            model
        };
        
        // 添加高级设置参数(如果有)
        if (advancedSettings) {
            requestData.advanced_settings = advancedSettings;
        }
        
        return fetch('/api/message', {
            method: 'POST',
            headers: {
                'Content-Type': 'application/json'
            },
            body: JSON.stringify(requestData)
        }).then(response => {
            if (!response.ok) {
                throw new Error('网络请求失败');
            }
            return response.json();
        });
    },

    /**
     * 生成图片
     * @param {Object} params - 生成参数
     * @param {string|null} sessionId - 会话ID
     * @param {string|null} messageId - 消息ID
     * @param {Object|null} advancedSettings - 高级设置参数
     * @returns {Promise} - 返回Promise对象
     */
    generateImages: (params, sessionId = null, messageId = null, advancedSettings = null) => {
        const requestData = {
            params,
            session_id: sessionId,
            message_id: messageId
        };
        
        // 添加高级设置参数(如果有)
        if (advancedSettings) {
            requestData.advanced_settings = advancedSettings;
        }
        
        return fetch('/api/generate', {
            method: 'POST',
            headers: {
                'Content-Type': 'application/json'
            },
            body: JSON.stringify(requestData)
        }).then(response => {
            if (!response.ok) {
                throw new Error('图片生成请求失败');
            }
            return response.json();
        });
    },

    /**
     * 获取历史记录列表
     * @returns {Promise} - 返回Promise对象
     */
    getHistoryList: () => {
        return fetch('/api/history')
            .then(response => {
                if (!response.ok) {
                    throw new Error('获取历史记录失败');
                }
                return response.json();
            });
    },

    /**
     * 获取特定会话的历史记录
     * @param {string} sessionId - 会话ID
     * @returns {Promise} - 返回Promise对象
     */
    getSessionHistory: (sessionId) => {
        return fetch(`/api/history/${sessionId}`)
            .then(response => {
                if (!response.ok) {
                    throw new Error('获取会话历史失败');
                }
                return response.json();
            });
    },

    /**
     * 删除会话
     * @param {string} sessionId - 会话ID
     * @returns {Promise} - 返回Promise对象
     */
    deleteSession: (sessionId) => {
        return fetch(`/api/history/${sessionId}`, {
            method: 'DELETE'
        }).then(response => {
            if (!response.ok) {
                throw new Error('删除会话失败');
            }
            return response.ok;
        });
    },

    /**
     * DeepSeek API - 自然语言处理
     * @param {string} message - 用户消息
     * @param {Array} history - 历史消息数组
     * @returns {Promise} - 返回Promise对象
     */
    deepseekNLP: (message, history = []) => {
        return fetch('/api/deepseek/nlp', {
            method: 'POST',
            headers: {
                'Content-Type': 'application/json'
            },
            body: JSON.stringify({
                message,
                history
            })
        }).then(response => {
            if (!response.ok) {
                throw new Error('DeepSeek NLP请求失败');
            }
            return response.json();
        });
    },

    /**
     * DeepSeek API - 解析用户请求为SD参数
     * @param {string} message - 用户消息
     * @returns {Promise} - 返回Promise对象
     */
    deepseekParseParams: (message) => {
        return fetch('/api/deepseek/parse-params', {
            method: 'POST',
            headers: {
                'Content-Type': 'application/json'
            },
            body: JSON.stringify({
                message
            })
        }).then(response => {
            if (!response.ok) {
                throw new Error('DeepSeek参数解析请求失败');
            }
            return response.json();
        });
    },

    /**
     * DeepSeek API - 流式响应（使用SSE）
     * @param {string} message - 用户消息
     * @param {Array} history - 历史消息数组
     * @param {Function} onChunk - 处理数据块的回调函数
     * @param {Function} onComplete - 响应完成的回调函数
     * @param {Function} onError - 错误处理的回调函数
     */
    deepseekStreamResponse: (message, history = [], onChunk, onComplete, onError) => {
        const eventSource = new EventSource(`/api/deepseek/stream?message=${encodeURIComponent(message)}`);
        
        eventSource.onmessage = (event) => {
            try {
                const data = JSON.parse(event.data);
                if (data.type === 'chunk') {
                    onChunk && onChunk(data.content);
                } else if (data.type === 'complete') {
                    onComplete && onComplete(data.content);
                    eventSource.close();
                }
            } catch (error) {
                console.error('Error parsing SSE data:', error);
                onError && onError(error);
                eventSource.close();
            }
        };
        
        eventSource.onerror = (error) => {
            console.error('SSE connection error:', error);
            onError && onError(error);
            eventSource.close();
        };
        
        // 返回EventSource实例，以便调用者可以手动关闭连接
        return eventSource;
    }
};

// 导出API模块
window.api = api;